home *** CD-ROM | disk | FTP | other *** search
/ Openstep 4.2 (Developer) / Openstep Developer 4.2.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / conn.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-20  |  12.2 KB  |  320 lines
  1. /* conn.h
  2.    Header file for routines which manipulate connections.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 1994 Ian Lance Taylor
  5.  
  6.    This file is part of the Taylor UUCP package.
  7.  
  8.    This program is free software; you can redistribute it and/or
  9.    modify it under the terms of the GNU General Public License as
  10.    published by the Free Software Foundation; either version 2 of the
  11.    License, or (at your option) any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful, but
  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.    General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21.  
  22.    The author of the program may be contacted at ian@airs.com or
  23.    c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
  24.    */
  25.  
  26. #ifndef CONN_H
  27.  
  28. #define CONN_H
  29.  
  30. #if ANSI_C
  31. /* These structures are used in prototypes but are not defined in this
  32.    header file.  */
  33. struct uuconf_system;
  34. struct uuconf_dialer;
  35. struct uuconf_chat;
  36. #endif
  37.  
  38. /* This structure represents a connection.  */
  39.  
  40. struct sconnection
  41. {
  42.   /* Pointer to command table for this type of connection.  */
  43.   const struct sconncmds *qcmds;
  44.   /* Pointer to system dependent information.  */
  45.   pointer psysdep;
  46.   /* Pointer to system independent information.  */
  47.   struct uuconf_port *qport;
  48. };
  49.  
  50. /* Whether fconn_dial got a dialer.  */
  51.  
  52. enum tdialerfound
  53. {
  54.   /* Did not find a dialer.  */
  55.   DIALERFOUND_FALSE,
  56.   /* Found a dialer which does not need to be freed.  */
  57.   DIALERFOUND_TRUE,
  58.   /* Found a dialer which does need to be freed.  */
  59.   DIALERFOUND_FREE
  60. };
  61.  
  62. /* Parity settings to pass to fconn_set.  */
  63.  
  64. enum tparitysetting
  65. {
  66.   /* Do not change output parity generation.  */
  67.   PARITYSETTING_DEFAULT,
  68.   /* No parity (all eight output bits used).  */
  69.   PARITYSETTING_NONE,
  70.   /* Even parity.  */
  71.   PARITYSETTING_EVEN,
  72.   /* Odd parity.  */
  73.   PARITYSETTING_ODD,
  74.   /* Mark parity.  */
  75.   PARITYSETTING_MARK,
  76.   /* Space parity.  */
  77.   PARITYSETTING_SPACE
  78. };
  79.  
  80. /* Type of strip control argument to fconn_set.  */
  81.  
  82. enum tstripsetting
  83. {
  84.   /* Do not change the stripping of input characters.  */
  85.   STRIPSETTING_DEFAULT,
  86.   /* Do not strip input characters to seven bits.  */
  87.   STRIPSETTING_EIGHTBITS,
  88.   /* Strip input characters to seven bits.  */
  89.   STRIPSETTING_SEVENBITS
  90. };
  91.  
  92. /* Type of XON/XOFF control argument to fconn_set.  */
  93.  
  94. enum txonxoffsetting
  95. {
  96.   /* Do not change XON/XOFF handshake setting.  */
  97.   XONXOFF_DEFAULT,
  98.   /* Do not do XON/XOFF handshaking.  */
  99.   XONXOFF_OFF,
  100.   /* Do XON/XOFF handshaking.  */
  101.   XONXOFF_ON
  102. };
  103.  
  104. /* A command table holds the functions which implement actions for
  105.    each different kind of connection.  */
  106.  
  107. struct sconncmds
  108. {
  109.   /* Free up a connection.  */
  110.   void (*pufree) P((struct sconnection *qconn));
  111.   /* Lock the connection.  The fin argument is TRUE if the connection
  112.      is to be used for an incoming call.  May be NULL.  */
  113.   boolean (*pflock) P((struct sconnection *qconn, boolean fin));
  114.   /* Unlock the connection.  May be NULL.  */
  115.   boolean (*pfunlock) P((struct sconnection *qconn));
  116.   /* Open the connection.  */
  117.   boolean (*pfopen) P((struct sconnection *qconn, long ibaud,
  118.                boolean fwait));
  119.   /* Close the connection.  */
  120.   boolean (*pfclose) P((struct sconnection *qconn,
  121.             pointer puuconf,
  122.             struct uuconf_dialer *qdialer,
  123.             boolean fsuccess));
  124.   /* Dial a number on a connection.  This set *qdialer to the dialer
  125.      used, if any, and sets *ptdialerfound appropriately.  The qsys
  126.      and zphone arguments are for the chat script.  This field may be
  127.      NULL.  */
  128.   boolean (*pfdial) P((struct sconnection *qconn, pointer puuconf,
  129.                const struct uuconf_system *qsys,
  130.                const char *zphone,
  131.                struct uuconf_dialer *qdialer,
  132.                enum tdialerfound *ptdialerfound));
  133.   /* Read data from a connection, with a timeout in seconds.  When
  134.      called *pclen is the length of the buffer; on successful return
  135.      *pclen is the number of bytes read into the buffer.  The cmin
  136.      argument is the minimum number of bytes to read before returning
  137.      ahead of a timeout.  */
  138.   boolean (*pfread) P((struct sconnection *qconn, char *zbuf, size_t *pclen,
  139.                size_t cmin, int ctimeout, boolean freport));
  140.   /* Write data to the connection.  */
  141.   boolean (*pfwrite) P((struct sconnection *qconn, const char *zbuf,
  142.             size_t clen));
  143.   /* Read and write data to the connection.  This reads and writes
  144.      data until either all passed in data has been written or the read
  145.      buffer has been filled.  When called *pcread is the size of the
  146.      read buffer and *pcwrite is the number of bytes to write; on
  147.      successful return *pcread is the number of bytes read and
  148.      *pcwrite is the number of bytes written.  */
  149.   boolean (*pfio) P((struct sconnection *qconn, const char *zwrite,
  150.              size_t *pcwrite, char *zread, size_t *pcread));
  151.   /* Send a break character.  This field may be NULL.  */
  152.   boolean (*pfbreak) P((struct sconnection *qconn));
  153.   /* Change the connection setting.  This field may be NULL.  */
  154.   boolean (*pfset) P((struct sconnection *qconn,
  155.               enum tparitysetting tparity,
  156.               enum tstripsetting tstrip,
  157.               enum txonxoffsetting txonxoff));
  158.   /* Require or ignore carrer.  This field may be NULL.  */
  159.   boolean (*pfcarrier) P((struct sconnection *qconn,
  160.               boolean fcarrier));
  161.   /* Run a chat program on a connection.  */
  162.   boolean (*pfchat) P((struct sconnection *qconn, char **pzprog));
  163.   /* Get the baud rate of a connection.  This field may be NULL.  */
  164.   long (*pibaud) P((struct sconnection *qconn));
  165. };
  166.  
  167. /* Connection functions.  */
  168.  
  169. /* Initialize a connection.  This must be called before any of the
  170.    other connection functions are called.  It initializes the fields
  171.    of qconn.  If qport is NULL, this opens standard input as a port
  172.    using type ttype.  This function returns FALSE on error.  */
  173. extern boolean fconn_init P((struct uuconf_port *qport,
  174.                  struct sconnection *qconn,
  175.                  enum uuconf_porttype ttype));
  176.  
  177. /* Free up connection data.  */
  178. extern void uconn_free P((struct sconnection *qconn));
  179.  
  180. /* Lock a connection.  The fin argument is TRUE if the port is to be
  181.    used for an incoming call; certains type of Unix locking need this
  182.    information because they need to open the port.  */
  183. extern boolean fconn_lock P((struct sconnection *qconn, boolean fin));
  184.  
  185. /* Unlock a connection.  */
  186. extern boolean fconn_unlock P((struct sconnection *qconn));
  187.  
  188. /* Open a connection.  If ibaud is 0, the natural baud rate of the
  189.    port is used.  If ihighbaud is not 0, fconn_open chooses the
  190.    highest supported baud rate between ibaud and ihighbaud.  If fwait
  191.    is TRUE, this should wait for an incoming call.  */
  192. extern boolean fconn_open P((struct sconnection *qconn, long ibaud,
  193.                  long ihighbaud, boolean fwait));
  194.  
  195. /* Close a connection.  The fsuccess argument is TRUE if the
  196.    conversation completed normally, FALSE if it is being aborted.  */
  197. extern boolean fconn_close P((struct sconnection *qconn,
  198.                   pointer puuconf,
  199.                   struct uuconf_dialer *qdialer,
  200.                   boolean fsuccess));
  201.  
  202. /* Dial out on a connection.  The qsys and zphone arguments are for
  203.    the chat scripts; zphone is the phone number to dial.  If qdialer
  204.    is not NULL, *qdialer will be set to the dialer information used if
  205.    any; *ptdialerfound will be set appropriately.  */
  206. extern boolean fconn_dial P((struct sconnection *q, pointer puuconf,
  207.                  const struct uuconf_system *qsys,
  208.                  const char *zphone,
  209.                  struct uuconf_dialer *qdialer,
  210.                  enum tdialerfound *ptdialerfound));
  211.  
  212. /* Read from a connection.
  213.    zbuf -- buffer to read bytes into
  214.    *pclen on call -- length of zbuf
  215.    *pclen on successful return -- number of bytes read
  216.    cmin -- minimum number of bytes to read before returning ahead of timeout
  217.    ctimeout -- timeout in seconds, 0 if none
  218.    freport -- whether to report errors.  */
  219. extern boolean fconn_read P((struct sconnection *qconn, char *zbuf,
  220.                  size_t *pclen, size_t cmin,
  221.                  int ctimeout, boolean freport));
  222.  
  223. /* Write to a connection.  */
  224. extern boolean fconn_write P((struct sconnection *qconn, const char *zbuf,
  225.                   size_t cbytes));
  226.  
  227. /* Read and write to a connection.  This reads and writes data until
  228.    either all passed-in data has been written or the read buffer is
  229.    full.
  230.    zwrite -- buffer to write bytes from
  231.    *pcwrite on call -- number of bytes to write
  232.    *pcwrite on successful return -- number of bytes written
  233.    zread -- buffer to read bytes into
  234.    *pcread on call -- size of read buffer
  235.    *pcread on successful return -- number of bytes read.  */
  236. extern boolean fconn_io P((struct sconnection *qconn, const char *zwrite,
  237.                size_t *pcwrite, char *zread, size_t *pcread));
  238.  
  239. /* Send a break character to a connection.  */
  240. extern boolean fconn_break P((struct sconnection *qconn));
  241.  
  242. /* Change the settings of a connection.  This allows independent
  243.    control over the parity of output characters, whether to strip
  244.    input characters, and whether to do XON/XOFF handshaking.  There is
  245.    no explicit control over parity checking of input characters.  This
  246.    function returns FALSE on error.  Attempts to set values not
  247.    supported by the hardware are silently ignored.  */
  248. extern boolean fconn_set P((struct sconnection *qconn,
  249.                 enum tparitysetting tparity,
  250.                 enum tstripsetting tstrip,
  251.                 enum txonxoffsetting txonxoff));
  252.  
  253. /* Get the baud rate of a connection.  */
  254. extern long iconn_baud P((struct sconnection *qconn));
  255.  
  256. /* Do a chat script with a system.  */
  257. extern boolean fchat P((struct sconnection *qconn, pointer puuconf,
  258.             const struct uuconf_chat *qchat,
  259.             const struct uuconf_system *qsys,
  260.             const struct uuconf_dialer *qdialer,
  261.             const char *zphone, boolean ftranslate,
  262.             const char *zport, long ibaud));
  263.  
  264. /* Tell the connection to either require or ignore carrier as fcarrier
  265.    is TRUE or FALSE respectively.  This is called with fcarrier TRUE
  266.    when \m is encountered in a chat script, and with fcarrier FALSE
  267.    when \M is encountered.  */
  268. extern boolean fconn_carrier P((struct sconnection *qconn,
  269.                 boolean fcarrier));
  270.  
  271. /* Run a chat program on a connection.  */
  272. extern boolean fconn_run_chat P((struct sconnection *qconn,
  273.                  char **pzprog));
  274.  
  275. /* Run through a dialer sequence.  This is a support routine for the
  276.    port type specific dialing routines.  */
  277. extern boolean fconn_dial_sequence P((struct sconnection *qconn,
  278.                       pointer puuconf, char **pzdialer,
  279.                       const struct uuconf_system *qsys,
  280.                       const char *zphone,
  281.                       struct uuconf_dialer *qdialer,
  282.                       enum tdialerfound *ptdialerfound));
  283.  
  284. /* Dialing out on a modem is partially system independent.  This is
  285.    the modem dialing routine.  */
  286. extern boolean fmodem_dial P((struct sconnection *qconn, pointer puuconf,
  287.                   const struct uuconf_system *qsys,
  288.                   const char *zphone,
  289.                   struct uuconf_dialer *qdialer,
  290.                   enum tdialerfound *ptdialerfound));
  291.  
  292. /* Begin dialing out.  This should open the dialer device if there is
  293.    one, toggle DTR if requested and possible, and tell the port to
  294.    ignore carrier.  It should return FALSE on error.  */
  295. extern boolean fsysdep_modem_begin_dial P((struct sconnection *qconn,
  296.                        struct uuconf_dialer *qdial));
  297.  
  298. /* Finish dialing out on a modem.  This should close the dialer device
  299.    if there is one.  If the dialer and the port both support carrier,
  300.    the connection should be told to pay attention to carrier.  If it
  301.    is possible to wait for carrier to come on, and the dialer and the
  302.    port both the port support carrier, it should wait until carrier
  303.    comes on.  */
  304. extern boolean fsysdep_modem_end_dial P((struct sconnection *qconn,
  305.                      struct uuconf_dialer *qdial));
  306.  
  307. /* System dependent initialization routines.  */
  308. extern boolean fsysdep_stdin_init P((struct sconnection *qconn));
  309. extern boolean fsysdep_modem_init P((struct sconnection *qconn));
  310. extern boolean fsysdep_direct_init P((struct sconnection *qconn));
  311. #if HAVE_TCP
  312. extern boolean fsysdep_tcp_init P((struct sconnection *qconn));
  313. #endif
  314. #if HAVE_TLI
  315. extern boolean fsysdep_tli_init P((struct sconnection *qconn));
  316. #endif
  317. extern boolean fsysdep_pipe_init P((struct sconnection *qconn));
  318.  
  319. #endif /* ! defined (CONN_H) */
  320.